home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 001 / pibt40s1.arc / DOSCRIPC.MOD < prev    next >
Encoding:
Text File  |  1987-05-25  |  10.6 KB  |  232 lines
  1. (*----------------------------------------------------------------------*)
  2. (*   Do_Script_Checks --- Check Script-related quantities for character *)
  3. (*----------------------------------------------------------------------*)
  4.  
  5. PROCEDURE Do_Script_Checks( Ch: CHAR );
  6.  
  7. (*----------------------------------------------------------------------*)
  8. (*                                                                      *)
  9. (*     Procedure:  Do_Script_Checks                                     *)
  10. (*                                                                      *)
  11. (*     Purpose:    Do script-related checks on character received       *)
  12. (*                 from comm port.                                      *)
  13. (*                                                                      *)
  14. (*     Calling Sequence:                                                *)
  15. (*                                                                      *)
  16. (*        Do_Script_Checks( Ch : CHAR );                                *)
  17. (*                                                                      *)
  18. (*           Ch         --- Character received from Comm. port.         *)
  19. (*                                                                      *)
  20. (*      Calls:   TimeOfDay                                              *)
  21. (*               TimeDiff                                               *)
  22. (*               Send_Function_Key                                      *)
  23. (*               CompareStr                                             *)
  24. (*               Check_Wait_String_Time                                 *)
  25. (*                                                                      *)
  26. (*----------------------------------------------------------------------*)
  27.  
  28. VAR
  29.    L  : INTEGER;
  30.    L2 : INTEGER;
  31.    I  : INTEGER;
  32.  
  33. LABEL 1;
  34.  
  35. (*----------------------------------------------------------------------*)
  36. (*         CmpS --- Check two equal-length strings for equality         *)
  37. (*----------------------------------------------------------------------*)
  38.  
  39. FUNCTION CmpS( VAR S1; VAR S2; N: INTEGER ) : BOOLEAN;
  40.  
  41. (*----------------------------------------------------------------------*)
  42. (*                                                                      *)
  43. (*     Here is a (very slow) Pascal version of this routine:            *)
  44. (*                                                                      *)
  45. (*     FUNCTION CmpS( VAR S1; VAR S2; N: INTEGER );                     *)
  46. (*                                                                      *)
  47. (*     TYPE                                                             *)
  48. (*        Byte_String = ARRAY[1..255] OF BYTE;                          *)
  49. (*                                                                      *)
  50. (*     VAR                                                              *)
  51. (*        BS1 : Byte_String ABSOLUTE S1;                                *)
  52. (*        BS2 : Byte_String ABSOLUTE S2;                                *)
  53. (*        B   : BOOLEAN;                                                *)
  54. (*        I   : INTEGER;                                                *)
  55. (*                                                                      *)
  56. (*     BEGIN                                                            *)
  57. (*                                                                      *)
  58. (*        B := TRUE;                                                    *)
  59. (*        I := 1;                                                       *)
  60. (*                                                                      *)
  61. (*        WHILE( B AND ( I <= N ) ) DO                                  *)
  62. (*           BEGIN                                                      *)
  63. (*              B := ( BS1[I] = BS2[I] );                               *)
  64. (*              I := SUCC( I );                                         *)
  65. (*           END;                                                       *)
  66. (*                                                                      *)
  67. (*        Cmps := B;                                                    *)
  68. (*                                                                      *)
  69. (*     END;                                                             *)
  70. (*                                                                      *)
  71. (*----------------------------------------------------------------------*)
  72.  
  73. BEGIN (* CmpS *)
  74.  
  75. INLINE(
  76.   $1E                    {          PUSH    DS               ;Save DS}
  77.   /$C5/$B6/>S1           {          LDS     SI,[BP+>S1]      ;Get first string address}
  78.   /$C4/$BE/>S2           {          LES     DI,[BP+>S2]      ;Get second string address}
  79.   /$8B/$8E/>N            {          MOV     CX,[BP+>N]       ;Get # characters to compare}
  80.   /$FC                   {          CLD                      ;Forward direction}
  81.   /$F3/$A6               {          REPE    CMPSB            ;Compare strings}
  82.   /$74/$05               {          JE      Matched          ;Skip if matched}
  83.   /$31/$C0               {          XOR     AX,AX            ;Flag indicates no match}
  84.   /$E9/$03/$00           {          JMP     Return}
  85.   /$B8/$01/$00           {Matched:  MOV     AX,1             ;Flag indicates match}
  86.   /$1F                   {Return:   POP     DS               ;Restore DS}
  87.   /$09/$C0               {          OR      AX,AX}
  88.   /$89/$EC               {          MOV     SP,BP}
  89.   /$5D                   {          POP     BP}
  90.   /$C2/$0B/$00           {          RET     11}
  91. );
  92.  
  93. END   (* CmpS *);
  94.  
  95. (*----------------------------------------------------------------------*)
  96.  
  97. BEGIN (* Do_Script_Checks *)
  98.                                    (* Skip checks for NUL, DEL    *)
  99.  
  100.    IF ( ( Ch = CHR( NUL ) ) OR ( Ch = CHR( DEL ) ) ) THEN
  101.       EXIT;
  102.                                    (* Check for WHEN string       *)
  103.    IF When_Mode THEN
  104.       BEGIN
  105.  
  106.          L := ORD(Script_When_Save[0]);
  107.  
  108.          IF L < ORD( Script_When_Text[0] ) THEN
  109.             BEGIN
  110.                L                   := SUCC( L );
  111.                Script_When_Save[L] := Ch;
  112.                Script_When_Save[0] := CHR( L );
  113.             END
  114.          ELSE
  115.             BEGIN
  116.  
  117.                MOVE( Script_When_Save[2], Script_When_Save[1], PRED( L ) );
  118.                Script_When_Save[L] := Ch;
  119.  
  120.                IF ( Script_When_Text[1] = Script_When_Save[1] ) THEN
  121.                   IF ( CmpS( Script_When_Text[1] , Script_When_Save[1] , L ) ) THEN
  122.                      BEGIN
  123.                         Script_When_Save[0] := #0;
  124.                         Send_Function_Key( Read_Ctrls( Script_When_Reply_Text ) );
  125.                      END;
  126.  
  127.             END;
  128.  
  129.       END (* When_Mode *);
  130.  
  131.                                    (* Check for WAITCOUNT *)
  132.    IF WaitCount_Mode THEN
  133.       BEGIN
  134.          Script_Wait_Char_Count := SUCC( Script_Wait_Char_Count );
  135.          IF ( Script_Wait_Char_Count >= Script_Wait_Check_Length ) THEN
  136.             BEGIN
  137.                WaitCount_Mode     := FALSE;
  138.                Really_Wait_String := FALSE;
  139.                Script_Wait_Found  := TRUE;
  140.             END
  141.          ELSE IF ( TimeDiff( Script_Wait_Start , TimeOfDay ) > Script_Wait_Time ) THEN
  142.             BEGIN
  143.                WaitCount_Mode      := FALSE;
  144.                Really_Wait_String  := FALSE;
  145.                Script_Wait_Found   := FALSE;
  146.             END;
  147.       END;
  148.                                    (* Check for WAITQUIET *)
  149.    IF WaitQuiet_Mode THEN
  150.       IF ( TimeDiffH( Script_Wait_Start , TimeOfDay ) >= Script_WaitQuiet_Time ) THEN
  151.          BEGIN
  152.             WaitQuiet_Mode      := FALSE;
  153.             Really_Wait_String  := FALSE;
  154.          END;
  155.  
  156.                                    (* Check for WAIT string       *)
  157.    IF WaitString_Mode THEN
  158.       BEGIN
  159.                                    (* Add in new character and        *)
  160.                                    (* check if wait string(s) present *)
  161.  
  162.          L := ORD( Script_Wait_Save[0] );
  163.  
  164.          IF ( L < Script_Wait_Check_Length ) THEN
  165.             BEGIN
  166.                Script_Wait_Save[L+1] := Ch;
  167.                Script_Wait_Save[0]   := CHR( SUCC( L ) );
  168.             END
  169.          ELSE
  170.             BEGIN
  171.                MOVE( Script_Wait_Save[2], Script_Wait_Save[1], PRED( L ) );
  172.                Script_Wait_Save[L] := Ch;
  173.             END;
  174.  
  175.          FOR I := 1 TO Script_Wait_Count DO
  176.             WITH Script_Wait_List[I] DO
  177.                BEGIN
  178.                   L2 := ORD(Wait_Text^[0]);
  179.                   IF( L >= L2 ) THEN
  180.                      IF ( Wait_Text^[1] = Script_Wait_Save[L - L2 + 1] ) THEN
  181.                         IF ( CmpS( Wait_Text^[1] ,
  182.                            Script_Wait_Save[L - L2 + 1], L2 ) ) THEN
  183.                            BEGIN
  184.                               Script_Wait_Save[0] := #0;
  185.                               Script_Wait_Found   := TRUE;
  186.                               WaitString_Mode     := FALSE;
  187.                               Really_Wait_String  := FALSE;
  188.                               IF ( Script_Wait_Result_Index > 0 ) THEN
  189.                                  Script_Variables^[Script_Wait_Result_Index].Var_Value^ :=
  190.                                      CHR( I ) + CHR( 0 );
  191.                               Send_Function_Key( Read_Ctrls( Wait_Reply^ ) );
  192.                               GOTO 1;
  193.                            END;
  194.                END;
  195.                                    (* Check if wait time exhausted *)
  196. 1:       IF WaitString_Mode THEN
  197.             Check_Wait_String_Time
  198.          ELSE                      (* Free up waitstring storage *)
  199.             BEGIN
  200.                FOR I := 1 TO Script_Wait_Count DO
  201.                   WITH Script_Wait_List[I] DO
  202.                      BEGIN
  203.                         DISPOSE( Wait_Text );
  204.                         DISPOSE( Wait_Reply );
  205.                      END;
  206.                Script_Wait_Count := 0;
  207.             END;
  208.  
  209.       END  (* WaitString_Mode *);
  210.  
  211.                                    (* Check for Script LEARN mode *)
  212.    IF Script_Learn_Mode THEN
  213.       BEGIN
  214.  
  215.          L := ORD( Script_String_2[0] );
  216.  
  217.          IF ( L < Script_Learn_Buffer_Size ) THEN
  218.             BEGIN
  219.                L                  := SUCC( L );
  220.                Script_String_2[L] := Ch;
  221.                Script_String_2[0] := CHR( L );
  222.             END
  223.          ELSE
  224.             BEGIN
  225.                MOVE( Script_String_2[2], Script_String_2[1],
  226.                      PRED( Script_Learn_Buffer_Size ) );
  227.                Script_String_2[Script_Learn_Buffer_Size] := Ch;
  228.             END;
  229.  
  230.       END (* Script_Learn_Mode *);
  231.  
  232. END    (* Do_Script_Checks *);